﻿/*
Nombre:                         CuentaDao
Descripcion:                    Casos de prueba realizados para la clase Electrocucaracha.AdminPersonal.DAO.LINQ.CuentaDao
Dependencias:                 
Fecha de creación:              20090114
Autor:                          VMORALES
Fecha de modifcación:         
Responsable:                  
Num. de modifcación:            0
*/

#region Imports

using NUnit.Framework;
using Electrocucaracha.AdminPersonal.DAO.Entidades;
using Spring.Context.Support;
using Spring.Context;
using log4net.Config;
using System.IO;
using System;
using System.Configuration;

#endregion

namespace Electrocucaracha.AdminPersonal.DAO.Test
{
    [TestFixture(Description="Casos de prueba realizados para la clase Electrocucaracha.AdminPersonal.DAO.LINQ.CuentaDao")]
    [Explicit("Requiere de preparacion de valores por defecto en la base de datos")]
    public class CuentaDao : GenericoDao<CuentaDao, CuentaDTO>
    {
        #region Constantes

        public const string DESCRIPCION = "Cuenta de prueba";
        public DateTime FECHA_CREACION = DateTime.Now;
        public const int ID = 1;
        public const int ID_BANCO = 0;
        public const int ID_TITULAR = 0;
        public const string NUM_CUENTA = "";

        #endregion

        #region Miembros

        public readonly static string INSTANCIA = "CuentaDao";
        private ICuentaDao dao;

        #endregion

        #region Propiedades

        #endregion

        #region Constructores

        #endregion

        #region Funciones

        /// <summary>
        /// Funcion que formatea la cuenta para que sea mostrado en el log
        /// </summary>
        /// <param name="cuenta">Instancia a ser formateada</param>
        /// <returns>Id, estatus y descripcion</returns>
        public override string Formatear(CuentaDTO cuenta)
        {
            return String.Format("id :\t{0}\t{1}\t{2}\t{3}\tDescripcion :{4}", 
                cuenta.Id,
                cuenta.NumCuenta,
                cuenta.FechaCreacion,
                (cuenta.Activo ? "Activo\t" : "Inactivo"),
                cuenta.Descripcion);
        }//Formatear

        /// <summary>
        /// Funcion que obtiene un objeto dao que comparten todas las pruebas
        /// </summary>
        [TestFixtureSetUp]
        public void Inicializar()
        {
            XmlConfigurator.Configure(new FileInfo("Log.xml"));
            IApplicationContext ctx = new XmlApplicationContext("file://DAO.xml");
            dao = (ICuentaDao)ctx.GetObject(CuentaDao.INSTANCIA);
            Assert.IsNotNull(dao, "No se pudo obtener una instancia dao para la tabla de cuentas");
        }//Inicializar

        /// <summary>
        /// Funcion que agrega datos temporales al catalogo para poder realizar pruebas
        /// </summary>
        [SetUp]
        public void AgregarDatos()
        {
            const int cantidadCuentasPrueba = 10;
            CuentaDTO temp = null;

            for (int i = 0; i < cantidadCuentasPrueba; i++)
            {
                temp = new CuentaDTO()
                {
                    Descripcion = DESCRIPCION,
                    FechaCreacion = FECHA_CREACION,
                    IdBanco = ID_BANCO,
                    IdTitular = ID_TITULAR,
                    NumCuenta = NUM_CUENTA
                };
                if (dao.Agregar(ref temp) && i % 2 == 1) 
                {
                    temp.Activo = false;
                    dao.Actualizar(temp);
                }
            }
        }//AgregarDatos

        /// <summary>
        /// Funcion que elimina los datos temporales del catalogo utilizados para las pruebas
        /// </summary>
        [TearDown]
        public void EliminarDatos()
        {
            foreach (CuentaDTO cuenta in dao.Obtener())
            {
                if(cuenta.Descripcion.Equals(DESCRIPCION) && 
                    cuenta.FechaCreacion.Date == FECHA_CREACION.Date && 
                    cuenta.IdBanco == ID_BANCO &&
                    cuenta.IdTitular == ID_TITULAR &&
                    cuenta.NumCuenta.Equals(NUM_CUENTA)){
                        dao.Eliminar(cuenta);
                }
            }
            if(dao.ObtenerCantidad() == 0)
                dao.ResetearId();
        }//EliminarDatos

        #endregion

        #region IGenericoDao

        /// <summary>
        /// Valida que se pueda agregar cuentas a la capa de persistencia
        /// </summary>
        [Test(Description = "Valida que se pueda agregar cuentas a la capa de persistencia")]
        [Category("IGenericoDao")]
        public void Agregar()
        {
            int cantidadAntes = dao.ObtenerCantidad();
            CuentaDTO cuentaPrueba = new CuentaDTO()
            {
                Descripcion = DESCRIPCION,
                FechaCreacion = FECHA_CREACION,
                IdBanco = ID_BANCO,
                IdTitular = ID_TITULAR,
                NumCuenta = NUM_CUENTA
            };

            Assert.IsNotNull(cuentaPrueba, "No se pudo inicializar los campos para el objeto a ser agregado");
            Assert.IsTrue(dao.Agregar(ref cuentaPrueba), "Ha ocurrido algun error al intentar agregar una cuenta");
            Assert.Greater(dao.ObtenerCantidad(), cantidadAntes, "No se vario la cantidad de cuentas despues de la accion de agregar");
        }//Agregar

        /// <summary>
        /// Valida que se pueda agregar varias cuentas a la capa de persistencia
        /// </summary>
        [Test(Description = "Valida que se pueda agregar varias cuentas a la capa de persistencia")]
        [Category("IGenericoDao")]
        public void AgregarVarios()
        {
            int cantidadAntes = dao.ObtenerCantidad();
            const int cantidadCuentasAgregar = 5;
            CuentaDTO[] cuentasPrueba = new CuentaDTO[cantidadCuentasAgregar];
            CuentaDTO temp = null;

            for (int i = 0; i < cuentasPrueba.Length; i++)
            {
                temp = new CuentaDTO()
                {
                    Descripcion = DESCRIPCION,
                    FechaCreacion = FECHA_CREACION,
                    IdBanco = ID_BANCO,
                    IdTitular = ID_TITULAR,
                    NumCuenta = NUM_CUENTA
                };
                cuentasPrueba[i] = temp;
            }

            Assert.IsNotEmpty(cuentasPrueba, "No se pudo inicializar las cuentas a ser agregadas");
            Assert.AreEqual(dao.Agregar(ref cuentasPrueba), cuentasPrueba.Length, "Ha ocurrido algun error al intentar agregar las cuentas");
            Assert.Greater(dao.ObtenerCantidad(), cantidadAntes, "No se vario la cantidad de cuentas despues de la accion de agregar");
        }//AgregarVarios

        /// <summary>
        /// Valida que se pueda eliminar una cuenta de la capa de persistencia
        /// </summary>
        [Test(Description = "Valida que se pueda eliminar una cuenta de la capa de persistencia")]
        [Category("IGenericoDao")]
        public void Eliminar()
        {
            int cantidadAntes = dao.ObtenerCantidad();

            CuentaDTO cuentaPrueba = dao.Obtener()[0];

            Assert.IsNotNull(cuentaPrueba, "No se pudo obtener una cuenta para ser eliminada");
            Assert.IsTrue(dao.Eliminar(cuentaPrueba), "Ha ocurrido algun error al intentar eliminar una cuenta");
            Assert.Less(dao.ObtenerCantidad(),  cantidadAntes, "No se vario la cantidad de cuentas despues de la accion de eliminar");
        }//Eliminar

        /// <summary>
        /// Valida que se pueda eliminar varias cuentas a la capa de persistencia
        /// </summary>
        [Test(Description = "Valida que se pueda eliminar varias cuentas a la capa de persistencia")]
        [Category("IGenericoDao")]
        public void EliminarVarios()
        {
            int cantidadAntes = dao.ObtenerCantidad();
            CuentaDTO[] cuentasPrueba = dao.ObtenerInactivos();

            Assert.IsNotEmpty(cuentasPrueba, "No se pudieron obtener cuentas inactivas para ser eliminadas");
            Assert.AreEqual(dao.Eliminar(cuentasPrueba), cuentasPrueba.Length, "Ha ocurrido algun error al intentar eliminar las cuentas");
            Assert.Less(dao.ObtenerCantidad(), cantidadAntes, "No se vario la cantidad de cuentas despues de la accion de eliminar");
        }//EliminarVarios

        /// <summary>
        /// Valida que se pueda obtener una cuenta a partir de su identificador
        /// </summary>
        [Test(Description = "Valida que se pueda obtener una cuenta a partir de su identificador")]
        [Category("IGenericoDao")]
        public void ObtenerPorId()
        {
            CuentaDTO cuentaPrueba = dao.Obtener(ID);

            Assert.IsNotNull(cuentaPrueba, "No se pudo obtener la cuenta con el identificador : " + ID);
        }//ObtenerPorId

        /// <summary>
        /// Valida que se pueda obtener todas las cuentas de la capa de persistencia
        /// </summary>
        [Test(Description = "Valida que se pueda obtener todas las cuentas de la capa de persistencia")]
        [Category("IGenericoDao")]
        public void ObtenerTodos()
        {
            CuentaDTO[] cuentasPrueba = dao.Obtener();

            Assert.IsNotEmpty(cuentasPrueba, "No se pudo obtener alguna cuenta de la capa de persistencia");
            Assert.AreEqual(cuentasPrueba.Length, dao.ObtenerCantidad(), "No se pudo obtener todas las cuentas de la capa de persistencia");
        }//ObtenerTodos

        /// <summary>
        /// Valida que se pueda actualizar una cuenta en la capa de persistencia
        /// </summary>
        [Test(Description = "Valida que se pueda actualizar una cuenta en la capa de persistencia")]
        [Category("IGenericoDao")]
        public void Actualizar()
        {
            const string nuevaDescripcion = "Actualizar";

            CuentaDTO cuentaPrueba = dao.Obtener(ID);
            Assert.IsNotNull(cuentaPrueba, "No se pudo obtener una cuenta para ser modificada");

            cuentaPrueba.Descripcion = nuevaDescripcion;
            Assert.IsTrue(dao.Actualizar(cuentaPrueba), "No se pudo actualizar la cuenta de prueba");

            cuentaPrueba = dao.Obtener(ID);
            Assert.AreEqual(cuentaPrueba.Descripcion, nuevaDescripcion, "No se pudo actualizar la descripcion de la cuenta en la capa de persistencia");
            Assert.IsTrue(dao.Eliminar(cuentaPrueba), "No se pudo eliminar la cuenta actualizada");
        }//Actualizar

        /// <summary>
        /// Valida que se pueda actualizar un conjunto de cuentas en la capa de persistencia
        /// </summary>
        [Test(Description = "Valida que se pueda actualizar un conjunto de cuentas en la capa de persistencia")]
        [Category("IGenericoDao")]
        public void ActualizarVarios()
        {
            const string nuevaDescripcion = "Actualizar";

            int cantidadAntes = dao.ObtenerCantidad();
            CuentaDTO[] cuentasPrueba = dao.ObtenerInactivos();
            Assert.IsNotEmpty(cuentasPrueba, "No se pudo obtener el conjunto de cuentas a actualizar");

            for (int i = 0; i < cuentasPrueba.Length; i++)
            {
                cuentasPrueba[i].Descripcion = nuevaDescripcion;
            }

            Assert.AreEqual(dao.Actualizar(cuentasPrueba), cuentasPrueba.Length, "Ha ocurrido algun error al intentar actualizar las cuentas");
            Assert.AreEqual(dao.Eliminar(cuentasPrueba), cuentasPrueba.Length, "No se pudieron eliminar las cuentas actualizadas");
        }//ActualizarVarios

        /// <summary>
        /// Valida que se pueda validar si existe una cuenta en particular
        /// </summary>
        [Test(Description = "Valida que se pueda validar si existe una cuenta en particular")]
        [Category("IGenericoDao")]
        public void Existe()
        {
            CuentaDTO cuentaExistente = dao.Obtener(ID);
            Assert.IsNotNull(cuentaExistente, "No se pudo obtener la cuenta con el identificador : " + ID);
            Assert.IsTrue(dao.Existe(cuentaExistente), "No se pudo encontrar una cuenta extraida de la capa de persistencia");

            CuentaDTO cuentaInexistente = new CuentaDTO();
            cuentaInexistente.Id = -1;
            Assert.IsFalse(dao.Existe(cuentaInexistente), "Se encontro una cuenta ficticia en la capa de persistencia");
        }//Existe

        /// <summary>
        /// Valida que se pueda resetear el identificador autoincremental
        /// </summary>
        [Test(Description = "Valida que se pueda resetear el identificador autoincremental")]
        [Category("IGenericoDao")]
        public void ResetearId()
        {
            CuentaDTO[] cuentas = dao.Obtener();
            Assert.IsNotEmpty(cuentas, "No se pudieron obtener todas las cuentas de la capa de persistencia");

            int ultimoId = cuentas[cuentas.Length - 1].Id;
            Assert.Greater(ultimoId, 0, "El ultimo identificador del catalogo de cuentas no es mayor a cero");

            //Vacio la tabla
            Assert.AreEqual(dao.Eliminar(cuentas), cuentas.Length, "Ha ocurrido algun error al intentar eliminar las cuentas");
            dao.ResetearId();

            CuentaDTO cuentaPrueba = new CuentaDTO()
            {
                Descripcion = DESCRIPCION,
                FechaCreacion = FECHA_CREACION,
                IdBanco = ID_BANCO,
                IdTitular = ID_TITULAR,
                NumCuenta = NUM_CUENTA
            };
            Assert.IsTrue(dao.Agregar(ref cuentaPrueba), "No se pudo agregar la cuenta de prueba al catalogo");

            cuentas = dao.Obtener();
            Assert.IsNotEmpty(cuentas, "No se pudieron obtener todas las cuentas de la capa de persistencia");
            Assert.Less(cuentas[cuentas.Length - 1].Id, ultimoId, "El id reseteado es mayor o igual al anterior");
            Assert.AreEqual(cuentas[cuentas.Length - 1].Id, 1, "El ultimo id no es igual a uno");

            Assert.IsTrue(dao.Eliminar(cuentaPrueba), "No se pudo eliminar la cuenta de prueba al catalogo");
        }//ResetearId

        /// <summary>
        /// Valida que se pueda obtener la cantidad de registros del catalogo de cuentas en la capa de persistencia
        /// </summary>
        [Test(Description = "Valida que se pueda obtener la cantidad de registros del catalogo de cuentas en la capa de persistencia")]
        [Category("IGenericoDao")]
        public void ObtenerCantidad()
        {
            int cantidad = dao.ObtenerCantidad();
            CuentaDTO[] cuentas = dao.Obtener();

            Assert.AreEqual(cuentas.Length, cantidad, "La cantidad de titulares no coincide");
        }//ObtenerCantidad

        #endregion

        #region IActivo

        /// <summary>
        /// Valida que se puedan obtener todas las cuentas activas de la capa de persistencia
        /// </summary>
        [Test(Description = "Valida que se puedan obtener todas las cuentas activas de la capa de persistencia")]
        [Category("IActivo")]
        public void ObtenerActivos()
        {
            CuentaDTO[] cuentas = dao.ObtenerActivos();
            Assert.IsNotEmpty(cuentas, "No existen cuentas activas o no se pudo obtener un conjunto de cuentas activas");
        }//ObtenerActivos

        /// <summary>
        /// Valida que se puedan obtener todas las cuentas inactivas de la capa de persistencia
        /// </summary>
        [Test(Description = "Valida que se puedan obtener todas las cuentas inactivas de la capa de persistencia")]
        [Category("IActivo")]
        public void ObtenerInactivos()
        {
            CuentaDTO[] cuentas = dao.ObtenerInactivos();
            Assert.IsNotEmpty(cuentas, "No existen titulares inactivas o no se pudo obtener un conjunto de cuentas inactivos");
        }//ObtenerInactivos

        /// <summary>
        /// Valida que se pueda activar una cuenta en la capa de persistencia
        /// </summary>
        [Test(Description = "Valida que se pueda activar una cuenta en la capa de persistencia")]
        [Category("IActivo")]
        public void Activar()
        {
            CuentaDTO[] cuentasInactivas = dao.ObtenerInactivos();
            Assert.IsNotEmpty(cuentasInactivas, "No existen cuentas inactivas o no se pudo obtener un conjunto de cuentas inactivas");
            CuentaDTO primerInactiva = cuentasInactivas[0];
            CuentaDTO inactivaBusqueda = null;

            Assert.IsNotNull(primerInactiva, "No se pudo obtener la primera cuenta inactiva del catalogo");
            Assert.IsTrue(dao.Activar(primerInactiva), "No se puedo activar la primera cuenta inactiva del catalogo");

            inactivaBusqueda = dao.Obtener(primerInactiva.Id);
            Assert.IsNotNull(inactivaBusqueda, "No se pudo obtener la cuenta con su nuevo estatus de activo");
            Assert.IsTrue(inactivaBusqueda.Activo, "No se pudo actualizar el estatus de la cuenta : " + inactivaBusqueda.Descripcion);
        }//Activar

        /// <summary>
        /// Valida que se pueda desactivar una cuenta en la capa de persistencia
        /// </summary>
        [Test(Description = "Valida que se pueda desactivar una cuenta en la capa de persistencia")]
        [Category("IActivo")]
        public void Desactivar()
        {
            CuentaDTO[] cuentasActivas = dao.ObtenerActivos();
            Assert.IsNotEmpty(cuentasActivas, "No existen cuentas activas o no se pudo obtener un conjunto de cuentas activos");
            CuentaDTO inactivaBusqueda = null;
            CuentaDTO primerActiva = cuentasActivas[0];

            Assert.IsNotNull(primerActiva, "No se pudo obtener la primera cuenta activa del catalogo");
            Assert.IsTrue(dao.Desactivar(primerActiva), "No se puedo desactivar la primera cuenta activa del catalogo");

            inactivaBusqueda = dao.Obtener(primerActiva.Id);
            Assert.IsNotNull(inactivaBusqueda, "No se pudo obtener la cuenta con su nuevo estatus de inactiva");
            Assert.IsFalse(inactivaBusqueda.Activo, "No se pudo actualizar el estatus de la cuenta : " + inactivaBusqueda.Descripcion);
        }//Desactivar

        #endregion

    }//CuentaDao
}//Electrocucaracha.AdminPersonal.DAO.Test